home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / util / misc / ReportPlus.lha / reportplus / source / f4.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-06-25  |  22.2 KB  |  665 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <proto/exec.h>
  4. #include <intuition/intuition.h>
  5. #include <intuition/gadgetclass.h>
  6. #include <proto/intuition.h>
  7. #include <libraries/gadtools.h>
  8. #include <proto/gadtools.h>
  9.  
  10. #include <ctype.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include "rp.h"
  14.  
  15. MODULE void bizarre(void);
  16. MODULE void updateautodocgadgets(void);
  17. MODULE void readautodocgadgets(void);
  18. MODULE void starify(ULONG theindex, STRPTR buffer);
  19. MODULE void countfields(void);
  20.  
  21. AGLOBAL UBYTE*               StarBufferPtr[MAXELEMENTS + 1];
  22. AGLOBAL ULONG                StarBufferSize[MAXELEMENTS + 1],
  23.                              returncode,
  24.                              inputs;
  25. AGLOBAL struct AutodocStruct autodoc;
  26.  
  27. MODULE struct Gadget *ST41_Library            = NULL,
  28.                      *ST41_Function           = NULL,
  29.                      *ST41_Desc               = NULL,
  30.                      *IN41_Version            = NULL,
  31.                      *TE41_Label              = NULL,
  32.                      *ST41_VarType[9],
  33.                      *ST41_VarName[9],
  34.                      *ST41_VarReg[9];
  35.  
  36. IMPORT struct NewGadget    Gadget;
  37. IMPORT struct Window*      MainWindowPtr;
  38. IMPORT struct SharedStruct shared;
  39. IMPORT struct Gadget      *BU99_Right,
  40.                           *BU99_TextEditor,
  41.                           *GListPtr,
  42.                           *PrevGadPtr;
  43. IMPORT ABOOL               react;
  44. IMPORT SBYTE               page;
  45. IMPORT TEXT                aslresult[MEDFIELD + 1],
  46.                            IOBuffer[LONGESTFIELD + 1];
  47. IMPORT ULONG               elements;
  48.  
  49. AGLOBAL void autodoc1(void)
  50. {   TEXT  temp[MEDFIELD + 1], string[9][MEDFIELD + 1];
  51.     UBYTE i;
  52.  
  53.     verynewwindow
  54.     (   AUTODOCWIDTH, AUTODOCHEIGHT,
  55.         "Report+: Autodocs Entry",
  56.         BUTTONIDCMP | STRINGIDCMP
  57.     );
  58.     OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_NEW,    NOSUB));
  59.     // OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_OPEN,   NOSUB));
  60.     OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_SAVE,   NOSUB));
  61.     OnMenu(MainWindowPtr, FULLMENUNUM(MN_PROJECT, IN_SAVEAS, NOSUB));
  62.  
  63.     /* library */
  64.     setgadget(128, 24, 200, 12, "module._type:", PLACETEXT_LEFT);
  65.     ST41_Library = PrevGadPtr = (struct Gadget *) CreateGadget
  66.     (   STRING_KIND,
  67.         PrevGadPtr,
  68.         &Gadget,
  69.         GTST_String, autodoc.library,
  70.         GTST_MaxChars, MEDFIELD,
  71.         GA_TabCycle, TRUE,
  72.         GT_Underscore, '_',
  73.         TAG_DONE
  74.     );
  75.  
  76.     /* version */
  77.     setgadget(544, 24, 64, 12, "Minimum _version:", PLACETEXT_LEFT);
  78.     IN41_Version = PrevGadPtr = (struct Gadget *) CreateGadget
  79.     (   INTEGER_KIND,
  80.         PrevGadPtr,
  81.         &Gadget,
  82.         GTIN_Number, autodoc.version,
  83.         GTST_MaxChars, MEDFIELD,
  84.         GA_TabCycle, TRUE,
  85.         GT_Underscore, '_',
  86.         TAG_DONE
  87.     );
  88.  
  89.     /* function */
  90.     setgadget(128, 38, 200, 12, "Function_Name:", PLACETEXT_LEFT);
  91.     ST41_Function = PrevGadPtr = (struct Gadget *) CreateGadget
  92.     (   STRING_KIND,
  93.         PrevGadPtr,
  94.         &Gadget,
  95.         GTST_String, autodoc.function,
  96.         GTST_MaxChars, MEDFIELD,
  97.         GA_TabCycle, TRUE,
  98.         GT_Underscore, '_',
  99.         TAG_DONE
  100.     );
  101.  
  102.     /* description */
  103.     setgadget(128, 52, 480, 12, "_Description:", PLACETEXT_LEFT);
  104.     ST41_Desc = PrevGadPtr = (struct Gadget *) CreateGadget
  105.     (   STRING_KIND,
  106.     PrevGadPtr,
  107.     &Gadget,
  108.         GTST_String, autodoc.description,
  109.     GTST_MaxChars, VLONGFIELD,
  110.     GA_TabCycle, TRUE,
  111.         GT_Underscore, '_',
  112.     TAG_DONE
  113.     );
  114.  
  115.     /* variable type */
  116.     setgadget(128, 72, 158, 1, "Type", PLACETEXT_BELOW);
  117.     TE41_Label = PrevGadPtr = (struct Gadget *) CreateGadget
  118.     (   TEXT_KIND,
  119.     PrevGadPtr,
  120.     &Gadget,
  121.     TAG_DONE
  122.     );
  123.  
  124.     strcpy(string[0], "_Return code:");
  125.     for (i = 1; i <= 8; i++)
  126.     {   strcpy(string[i], "Argument _");
  127.         stcl_d(temp, i);
  128.         strcat(string[i], temp);
  129.         strcat(string[i], ":");
  130.     }
  131.     for (i = 0; i <= 8; i++)
  132.     {   setgadget(128, 88 + (i * 14), 158, 12, string[i], PLACETEXT_LEFT);
  133.         ST41_VarType[i] = PrevGadPtr = (struct Gadget *) CreateGadget
  134.         (   STRING_KIND,
  135.             PrevGadPtr,
  136.             &Gadget,
  137.             GTST_String, &(autodoc.var[i].type),
  138.             GTST_MaxChars, MEDFIELD,
  139.             GA_TabCycle, TRUE,
  140.             GT_Underscore, '_',
  141.             TAG_DONE
  142.         );
  143.         if (i == 0)
  144.             setgadget(288, 88 + (i * 14), 256, 12, "Name", PLACETEXT_ABOVE);
  145.         else setgadget(288, 88 + (i * 14), 256, 12, NULL, NULL);
  146.         ST41_VarName[i] = PrevGadPtr = (struct Gadget *) CreateGadget
  147.         (   STRING_KIND,
  148.             PrevGadPtr,
  149.             &Gadget,
  150.             GTST_String, &(autodoc.var[i].name),
  151.             GTST_MaxChars, MEDFIELD,
  152.             GA_TabCycle, TRUE,
  153.             TAG_DONE
  154.         );
  155.         if (i == 0)
  156.             setgadget(544, 88 + (i * 14), 64, 12, "Register", PLACETEXT_ABOVE);
  157.         else setgadget(544, 88 + (i * 14), 64, 12, NULL, NULL);
  158.         ST41_VarReg[i] = PrevGadPtr = (struct Gadget *) CreateGadget
  159.         (   STRING_KIND,
  160.             PrevGadPtr,
  161.             &Gadget,
  162.             GTST_String, &(autodoc.var[i].reg),
  163.             GTST_MaxChars, MEDFIELD,
  164.             GA_TabCycle, TRUE,
  165.             TAG_DONE
  166.         );
  167.     }
  168.  
  169.     /* text editor... */
  170.     setgadget(250, 220, 140, 12, "Text ed_itor...", NULL);
  171.     BU99_TextEditor = PrevGadPtr = (struct Gadget *) CreateGadget
  172.     (   BUTTON_KIND,
  173.         PrevGadPtr,
  174.         &Gadget,
  175.         GT_Underscore, '_',
  176.         TAG_DONE
  177.     );
  178.  
  179.     drawgadgets((UWORD) ~0);
  180.     loop();
  181.     readautodocgadgets();
  182.     closewindow();
  183. }
  184.  
  185. AGLOBAL void saveautodoc(ABOOL saveas)
  186. {   ULONG i, j;
  187.     TEXT  temp[MEDFIELD + 1];
  188.     SWORD size;
  189.  
  190.     readautodocgadgets();
  191.    
  192.     strcpy(IOBuffer, "/" "****** ");        //  1:  "/###### "
  193.     strcat(IOBuffer, autodoc.library);      //  1:  "/###### <library>"
  194.     strcat(IOBuffer, "/");                  //  1:  "/###### <library>/"
  195.     strcat(IOBuffer, autodoc.function);     //  1:  "/###### <library>/<function>"
  196.     strcat(IOBuffer, " ");                  //  1:  "/###### <library>/<function> "
  197.  
  198.     size = 67 - strlen(autodoc.library) - strlen(autodoc.function);
  199.     if (size > 0)
  200.     {   for (i = 1; i <= size; i++)           
  201.             strcat(IOBuffer, "*");          //  1:  "/###### <library>/<function> <stars>"
  202.     }
  203.  
  204.     strcat(IOBuffer, "\n*\n*   NAME\n*   ");
  205.                                             //  1:  "/###### <library>/<function> <stars>\n"
  206.                                             //  2:  "#\n"
  207.                                             //  3:  "#   NAME\n"
  208.                                             //  4:  "#   "
  209.     strcat(IOBuffer, autodoc.function);     //  4:  "#   <function>"
  210.     strcat(IOBuffer, " -- ");               //  4:  "#   <function> -- "
  211.     strcat(IOBuffer, autodoc.description);
  212.                                             //  4:  "#   <function> -- <description>"
  213.     if (autodoc.version)
  214.     {   strcat(IOBuffer, " (V");            //  4:  "#   <function> -- <description>[ (V]"
  215.         stcl_d(temp, autodoc.version);
  216.         strcat(IOBuffer, temp);             //  4:  "#   <function> -- <description>[ (V<version>]"
  217.         strcat(IOBuffer, ")");              //  4:  "#   <function> -- <description>[ (V<version>)]
  218.     }
  219.     strcat(IOBuffer, "\n*\n*   SYNOPSIS\n");
  220.                                             //  4:  "#   <function> -- <description>[ (V<version>)]\n"
  221.                                             //  5:  "#\n"
  222.                                             //  6:  "#   SYNOPSIS\n"
  223.  
  224.     // name line
  225.     strcat(IOBuffer, "*   ");               //  7:  "#   "
  226.     if (autodoc.var[0].name[0])
  227.     {   strcat(IOBuffer, autodoc.var[0].name);
  228.                                             //  7:  "#   [<returnname>]"
  229.         strcat(IOBuffer, " = ");            //  7:  "#   [<returnname> = ]"
  230.     }
  231.     strcat(IOBuffer, autodoc.function);     //  7:  "#   [<returnname> = ]<function>"
  232.     strcat(IOBuffer, "(");                  //  7:  "#   [<returnname> = ]<function>("
  233.  
  234.     for (i = 1; i <= 8; i++)
  235.     {   if (autodoc.var[i].name[0])
  236.         {   if (i >= 2)
  237.                 strcat(IOBuffer, ", ");
  238.             strcat(IOBuffer, autodoc.var[i].name);
  239.             size = strlen(autodoc.var[i].reg) - strlen(autodoc.var[i].name);
  240.             if (size > 0)
  241.                 for (j = 1; j <= size; j++)
  242.                     strcat(IOBuffer, " ");
  243.         } else break;
  244.     }
  245.     strcat(IOBuffer, ")\n");                //  7:  "#   [<returnname> = ]<function>([<arglist>])\n"
  246.  
  247.     // register line
  248.     strcat(IOBuffer, "*   ");               //  8:  "#   "
  249.     if (autodoc.var[0].reg[0] && autodoc.var[0].name[0])
  250.     {   strcat(IOBuffer, autodoc.var[0].reg);
  251.                                             //  8:  "#   [<returnreg>]"
  252.         size = strlen(autodoc.var[0].name) - strlen(autodoc.var[0].reg);
  253.         if (size > 0)
  254.             for (i = 1; i <= size; i++)
  255.                 strcat(IOBuffer, " ");      //  8:  "#   [<returnreg><spaces>]"
  256.         strcat(IOBuffer, "   ");            //  8:  "#   [<returnreg><spaces>   ]"
  257.     }
  258.     size = strlen(autodoc.function);
  259.     if (size >= 0) // this is no mistake
  260.         for (i = 0; i <= size; i++)
  261.             strcat(IOBuffer, " ");          //  8:  "#   [<returnreg><spaces>   ]<spaces>"
  262.  
  263.     for (i = 1; i <= 8; i++)
  264.     {   if (autodoc.var[i].reg[0])
  265.         {   if (i >= 2)
  266.                 strcat(IOBuffer, "  ");
  267.             strcat(IOBuffer, autodoc.var[i].reg);
  268.             size = strlen(autodoc.var[i].name) - strlen(autodoc.var[i].reg);
  269.             if (size > 0)
  270.                 for (j = 1; j <= size; j++)
  271.                     strcat(IOBuffer, " ");
  272.     }   }
  273.     strcat(IOBuffer, "\n");                 //  8:  "#   [<returnreg><spaces>   ]<spaces>[<reglist>]\n"
  274.  
  275.     strcat(IOBuffer, "*\n*   ");            //  9:  "#\n"
  276.                                             // 10:  "#   "
  277.     if (autodoc.var[0].type[0])
  278.     {   strcat(IOBuffer, autodoc.var[0].type);
  279.                                             // 10a: "#   <returntype>"
  280.         strcat(IOBuffer, " ");              // 10a: "#   <returntype> "
  281.     } else
  282.         strcat(IOBuffer, "void ");          // 10b: "#   void "
  283.     strcat(IOBuffer, autodoc.function);     // 10:  "#   <returntype>|void <function>"
  284.     strcat(IOBuffer, "(");                  // 10:  "#   <returntype>|void <function>("
  285.     if (!(autodoc.var[1].type))             // 10:  "#   <returntype>|void <function>([void]"
  286.         strcat(IOBuffer, "void");
  287.     else
  288.     {   for (i = 1; i <= 8; i++)
  289.         {   if (autodoc.var[i].type[0])
  290.             {   if (i >= 2)
  291.                     strcat(IOBuffer, ", ");
  292.                 strcat(IOBuffer, autodoc.var[i].type);
  293.             } else break;
  294.     }   }
  295.     strcat(IOBuffer, ");\n*\n*   FUNCTION\n*   ");
  296.                                             // 10:  "#   <returntype>|void <function>(void|<typelist>);\n"
  297.                                             // 11:  "#\n"
  298.                                             // 12:  "#   FUNCTION\n"
  299.                                             // 13:  "#   "
  300.     if (react)
  301.         strcat(IOBuffer, StarBufferPtr[0]);
  302.     else strcat(IOBuffer, "!");             // 13:  "#   <buffer>"
  303.     strcat(IOBuffer, "\n*\n*   INPUTS\n");  // 13:  "#   <buffer>\n"
  304.                                             // 14:  "#\n"
  305.                                             // 15:  "#   INPUTS\n"
  306.  
  307.     bizarre();
  308.  
  309.     strcat(IOBuffer, "*\n*   RESULT\n*   ");
  310.                                             // 17:  "#\n"
  311.                                             // 18:  "#   RESULT\n"
  312.                                             // 19:  "#   "
  313.     if (!(autodoc.var[0].name[0]))
  314.         strcat(IOBuffer, "NONE");           // 19a: "#   NONE"
  315.     else
  316.     {   strcat(IOBuffer, autodoc.var[0].name);
  317.                                             // 19b: "#   <returnname>"
  318.         strcat(IOBuffer, " - ");            // 19b: "#   <returnname> - "
  319.         if (react)
  320.             strcat(IOBuffer, StarBufferPtr[5]);
  321.         else strcat(IOBuffer, "!");         // 19b: "#   <returnname> - <buffer>"
  322.     }
  323.  
  324.     strcat
  325.     (   IOBuffer,
  326.         "\n*\n"                             // 19a: "#   NONE\n"
  327.                                             // 19b: "#   <returnname> - <buffer>\n"
  328.                                             // 20:  "#\n"
  329.         "*   EXAMPLE\n*   "                 // 21:  "#   EXAMPLE\n"
  330.                                             // 22:  "#   "
  331.     );
  332.  
  333.     if (react)
  334.         strcat(IOBuffer, StarBufferPtr[1]);
  335.     else strcat(IOBuffer, "!");             // 22:  "#   <buffer>"
  336.     strcat(IOBuffer, "\n*\n*   NOTES\n*   ");
  337.                                             // 22:  "#   <buffer>\n"
  338.                                             // 23:  "#\n"
  339.                                             // 24:  "#   NOTES\n"
  340.                                             // 25:  "#   "
  341.  
  342.     if (react)
  343.         strcat(IOBuffer, StarBufferPtr[2]);
  344.     else strcat(IOBuffer, "!");             // 25:  "#   <buffer>"
  345.     strcat(IOBuffer, "\n*\n*   BUGS\n*   ");
  346.                                             // 25:  "#   <buffer>\n"
  347.                                             // 26:  "#\n"
  348.                                             // 27:  "#   BUGS\n"
  349.                                             // 28:  "#   "
  350.     if (react)
  351.         strcat(IOBuffer, StarBufferPtr[3]);
  352.     else strcat(IOBuffer, "!");             // 28:  "#   <buffer>"
  353.     strcat(IOBuffer, "\n*\n*   SEE ALSO\n*   ");
  354.                                             // 28:  "#   <buffer>\n"
  355.                                             // 29:  "#\n"
  356.                                             // 30:  "#   SEE ALSO\n"
  357.                                             // 31:  "#   "
  358.  
  359.     if (react)
  360.         strcat(IOBuffer, StarBufferPtr[4]);
  361.     else strcat(IOBuffer, "!");             // 31:  "#   <buffer>"
  362.  
  363.     strcat
  364.     (   IOBuffer,
  365.         "\n*\n"                             // 31:  "#   <buffer>\n"
  366.                                             // 32:  "#\n"
  367.         "*****************************************************************************\n"
  368.                                             // 33:  "<77 stars>\n"
  369.         "*\n*"                              // 34:  "#\n"
  370.                                             // 35:  "#"
  371.         "/\n"                               // 35:  "#/\n"
  372.     );
  373.  
  374.     // if (!react) then StarBufferPtr[]s should be NULL anyway
  375.     for (i = 0; i <= MAXELEMENTS; i++)
  376.     {   if (StarBufferPtr[i])
  377.         {   FreeMem(StarBufferPtr[i], StarBufferSize[i]);
  378.             StarBufferPtr[i] = NULL;
  379.     }   }
  380.     // That was done as soon as possible, and also before anything that
  381.     // might fail.
  382.  
  383.     if (!autodoc.output[0] || saveas) // if we need a filename
  384.     {   if (saveasl("Save Autodoc"))
  385.         {   strcpy(autodoc.output, aslresult);
  386.             writeout(autodoc.output);
  387. }   }   }
  388.  
  389. MODULE void bizarre(void)
  390. {   // Service routine for autodoc2().
  391.  
  392.     ULONG i, j;
  393.     SWORD size, longest = 0, thislength; // must be signed
  394.     TEXT  line[VLONGFIELD + 1]; // better not make it too large, as it is
  395.                                 // a local (stack) variable.
  396.  
  397.     if (!inputs)
  398.     {   strcpy(line, "*   NONE\n");         // 16:  "#   NONE\n"
  399.     } else
  400.     {   for (i = 1; i <= inputs; i++)
  401.         {   thislength = strlen(autodoc.var[i].name);
  402.             if (thislength > longest)
  403.             {   longest = thislength;
  404.         }   }
  405.  
  406.         for (i = 1; i <= inputs; i++)
  407.         {   strcpy(line, "*   ");           // 16:  "#   "
  408.             strcat(line, autodoc.var[i].name);
  409.                                             // 16:  "#   <argname1>"
  410.             thislength = strlen(autodoc.var[i].name);
  411.             size = longest - thislength;
  412.             if (size > 0)
  413.             {   for (j = 1; j <= size; j++)
  414.                 {    strcat(line, " ");     // 16:  "#   <argname1><spaces>"
  415.             }   }
  416.             strcat(line, " - ");            // 16:  "#   <argname1><spaces> - "
  417.             if (react)
  418.             {   strcat(line, StarBufferPtr[5 + i]);
  419.             } else
  420.             {   strcat(line, "!");          // 16:  "#   <argname1><spaces> - <buffer1>"
  421.             }
  422.             strcat(line, "\n");             // 16:  "#   <argname1><spaces> - <buffer1>\n"
  423.     }   }
  424.     strcat(IOBuffer, line);
  425. }
  426.  
  427. AGLOBAL void newautodoc(ABOOL display)
  428. {   ULONG i;
  429.  
  430.     autodoc.version = 0;
  431.     autodoc.loaded = FALSE;
  432.     strcpy(autodoc.library,     "");
  433.     strcpy(autodoc.function,    "");
  434.     strcpy(autodoc.description, "");
  435.     for (i = 0; i <= 8; i++)
  436.     {   autodoc.var[i].name[0] = 0;
  437.         autodoc.var[i].type[0] = 0;
  438.         autodoc.var[i].reg[0]  = 0;
  439.         autodoc.var[i].desc[0] = 0;
  440.     }
  441.     strcpy(autodoc.output,      "");
  442.  
  443.     if (display)
  444.         updateautodocgadgets();
  445. }
  446.  
  447. AGLOBAL void openautodoc(void)
  448. {   // as you can see, this is not yet implemented!
  449.  
  450.     updateautodocgadgets();
  451. }
  452.  
  453. AGLOBAL void autodoc_init(void)
  454. {   ULONG i;
  455.  
  456.     // array clearing
  457.     for (i = 0; i <= MAXELEMENTS; i++)
  458.     {   StarBufferPtr[i] = NULL;
  459.     }
  460.     newautodoc(FALSE);
  461. }
  462.  
  463. AGLOBAL void autodoc_loop(ULONG class, struct Gadget* addr, UWORD code)
  464. {   ULONG i;
  465.  
  466.     if (class == IDCMP_VANILLAKEY)
  467.     {   code = toupper(code);
  468.         if (code == ESCAPE)
  469.         {   page = 0;
  470.         } elif (code == 'R')
  471.         {   ActivateGadget(ST41_VarType[0], MainWindowPtr, NULL);
  472.         } elif (code >= '1' && code <= '8')
  473.         {   ActivateGadget(ST41_VarType[code - '1' + 1], MainWindowPtr, NULL);
  474.         } elif (code == 'T')
  475.         {   ActivateGadget(ST41_Library, MainWindowPtr, NULL);
  476.         } elif (code == 'N')
  477.         {   ActivateGadget(ST41_Function, MainWindowPtr, NULL);
  478.         } elif (code == 'D')
  479.         {   ActivateGadget(ST41_Desc, MainWindowPtr, NULL);
  480.         } elif (code == 'V')
  481.         {   ActivateGadget(IN41_Version, MainWindowPtr, NULL);
  482.         } elif (code == 'I')
  483.         {   if (!react)
  484.             {   saveautodoc(FALSE);
  485.             }
  486.             countfields();
  487.             launcheditor(autodoc.output);
  488.  
  489.             /* StarBufferPtr[]s are as follows:
  490.             0: Function
  491.             1: Example
  492.             2: Notes
  493.             3: Bugs
  494.             4: See also
  495.             5: Return code
  496.          6-13: Inputs */
  497.  
  498.             for (i = 0; i <= 4; i++)
  499.             {   starify(i, autodoc.textfield[i]);
  500.             }
  501.             if (returncode)
  502.             {   starify(5, autodoc.var[0].desc);
  503.             }
  504.             if (inputs)
  505.             {   for (i = 1; i <= inputs; i++)
  506.                 {   starify(5 + i, autodoc.var[i].desc);
  507.     }   }   }   }
  508.     elif (class == IDCMP_GADGETUP)
  509.     {   if (addr == BU99_Right)
  510.         {   page = 0;
  511.         } elif (addr == BU99_TextEditor)
  512.         {   if (!react)
  513.             {   saveautodoc(FALSE);
  514.             }
  515.             countfields();
  516.             launcheditor(autodoc.output);
  517.  
  518.             for (i = 0; i <= 4; i++)
  519.             {   starify(i, autodoc.textfield[i]);
  520.             }
  521.             if (returncode)
  522.             {   starify(5, autodoc.var[0].desc);
  523.             }
  524.             if (inputs)
  525.             {   for (i = 1; i <= inputs; i++)
  526.                 {   starify(5 + i, autodoc.var[i].desc);
  527. }   }   }   }   }
  528.  
  529. MODULE void updateautodocgadgets(void)
  530. {   ULONG i;
  531.  
  532.     GT_SetGadgetAttrs
  533.     (   ST41_Library,
  534.         MainWindowPtr,
  535.         NULL,
  536.         GTST_String, autodoc.library,
  537.         TAG_DONE
  538.     );
  539.     GT_SetGadgetAttrs
  540.     (   ST41_Function,
  541.         MainWindowPtr,
  542.         NULL,
  543.         GTST_String, autodoc.function,
  544.         TAG_DONE
  545.     );
  546.     GT_SetGadgetAttrs
  547.     (   ST41_Desc,
  548.         MainWindowPtr,
  549.         NULL,
  550.         GTST_String, autodoc.description,
  551.         TAG_DONE
  552.     );
  553.     GT_SetGadgetAttrs
  554.     (   IN41_Version,
  555.         MainWindowPtr,
  556.         NULL,
  557.         GTIN_Number, autodoc.version,
  558.         TAG_DONE
  559.     );
  560.     for (i = 0; i <= 8; i++)
  561.     {   GT_SetGadgetAttrs
  562.         (   ST41_VarType[i],
  563.             MainWindowPtr,
  564.             NULL,
  565.             GTST_String, autodoc.var[i].type,
  566.             TAG_DONE
  567.         );
  568.         GT_SetGadgetAttrs
  569.         (   ST41_VarName[i],
  570.             MainWindowPtr,
  571.             NULL,
  572.             GTST_String, autodoc.var[i].name,
  573.             TAG_DONE
  574.         );
  575.         GT_SetGadgetAttrs
  576.         (   ST41_VarReg[i],
  577.             MainWindowPtr,
  578.             NULL,
  579.             GTST_String, autodoc.var[i].reg,
  580.             TAG_DONE
  581.         );
  582. }   }
  583.  
  584. MODULE void readautodocgadgets(void)
  585. {   ULONG i;
  586.  
  587.     strcpy
  588.     (   autodoc.library,
  589.         ((struct StringInfo *) ST41_Library->SpecialInfo)->Buffer
  590.     );
  591.     strcpy
  592.     (   autodoc.function,
  593.         ((struct StringInfo *) ST41_Function->SpecialInfo)->Buffer
  594.     );
  595.     strcpy
  596.     (   autodoc.description,
  597.         ((struct StringInfo *) ST41_Desc->SpecialInfo)->Buffer
  598.     );
  599.     autodoc.version = ((struct StringInfo *) IN41_Version->SpecialInfo)->LongInt;
  600.     for (i = 0; i <= 8; i++)
  601.     {   strcpy
  602.         (   autodoc.var[i].type,
  603.             ((struct StringInfo *) ST41_VarType[i]->SpecialInfo)->Buffer
  604.         );
  605.         strcpy
  606.         (   autodoc.var[i].name,
  607.             ((struct StringInfo *) ST41_VarName[i]->SpecialInfo)->Buffer
  608.         );
  609.         strcpy
  610.         (   autodoc.var[i].reg,
  611.             ((struct StringInfo *) ST41_VarReg[i]->SpecialInfo)->Buffer
  612.         );
  613. }   }
  614.  
  615. MODULE void starify(ULONG theindex, STRPTR buffer)
  616. {   ULONG j, length, where;
  617.     ABOOL done;
  618.  
  619.     // first we count the number of LFs in the source buffer, and the
  620.     // length of the source buffer.
  621.     length = 0;
  622.     done = FALSE;
  623.     while (!done)
  624.     {   if (*(buffer + length) == LF)
  625.             StarBufferSize[theindex] += 4;
  626.         elif (*(buffer + length) == 0)
  627.             done = TRUE;
  628.         StarBufferSize[theindex]++;
  629.         length++;
  630.     }
  631.  
  632.     // now we allocate the buffer
  633.     if (!(StarBufferPtr[theindex] = AllocMem(StarBufferSize[theindex], MEMF_PUBLIC)))
  634.         rq("Out of memory!");
  635.  
  636.     // now we translate into new buffer
  637.     where = 0;
  638.     for (j = 0; j <= length; j++)
  639.     {   *(StarBufferPtr[theindex] + where) = *(buffer + j);
  640.         if (*(buffer + j) == LF)
  641.         {   *(StarBufferPtr[theindex] + where + 1) = '*';
  642.             *(StarBufferPtr[theindex] + where + 2) = ' ';
  643.             *(StarBufferPtr[theindex] + where + 3) = ' ';
  644.             *(StarBufferPtr[theindex] + where + 4) = ' ';
  645.             where += 4;
  646.         }
  647.         where++;
  648. }   }
  649.  
  650. MODULE void countfields(void)
  651. {   ULONG i;
  652.  
  653.     readautodocgadgets();
  654.  
  655.     if (autodoc.var[0].name[0])
  656.         returncode = 1; // non-boolean as it's used mathematically
  657.     else returncode = 0;
  658.  
  659.     inputs = 0;
  660.     for (i = 1; i <= 8; i++)
  661.     {   if (autodoc.var[i].name[0])
  662.             inputs++;
  663.         else break;
  664. }   }
  665.